home *** CD-ROM | disk | FTP | other *** search
/ Amiga Mag HDD Backup / Amiga Mag HDD Backup.zip / Amiga Mag HDD Backup / Alexander.img.bin / Alexander.img / ***9.11 All NEWer important / Stockman⁄StructDraw Post / HPGL2.asc < prev    next >
Text File  |  1994-09-16  |  25KB  |  407 lines
  1. Douglas Stockman
  2.  
  3. Creating Structured Drawings - Part 2: HP-GL/2
  4.  
  5. In the first structured drawing format article I introduced the concept of a structured drawing and 
  6. discussed the PostScript language.  This article focuses on the Hewlett Packard Graphics Language 
  7. (HP-GL/2) standard.  HP-GL/2 is most commonly used when sending output to graphics plotters, 
  8. although some programs use it to store and transfer structured graphics.  A number of different versions 
  9. of HP-GL exist.  HP-GL/2 is the most current standard and will be the focus of this article.  Older 
  10. plotters such as HP's 7475A do not support HP-GL/2, but rather a more limited and earlier version of 
  11. HP-GL.  The concepts on how to use each version of HP-GL are the same, but some of the commands 
  12. differ.  A list of references are provided at the end of this article for both an early version of HP-GL and 
  13. the current standard HP-GL/2.
  14.  
  15. For the beginning programmer, an attractive feature of the language is that HP-GL/2 commands are 
  16. saved as ASCII text.  Therefore, an HP-GL/2 defined structured drawing can be created using a text 
  17. editor.  It is also easier to debug code that outputs HP-GL/2 commands because errors in the program's 
  18. output can be viewed with a text editor.  One drawback to learning HP-GL/2 on the Amiga is that no 
  19. software interpreter exists for HP-GL/2 commands such as Post for PostScript.  A software interpreter 
  20. named PLT does exist for an earlier version of the HP-GL standard, but as of 12/93 this interpreter did 
  21. not support HP-GL/2.  Therefore, to truly debug HP-GL/2 generating code, the programmer must find an 
  22. HP-GL/2 capable device such as a plotter.  For those who are developing commercial applications, HP 
  23. does have a peripherals developer support program which allows programmers to borrow plotters.
  24.  
  25. HP-GL/2 commands are two letter mnemonics.  For example, the command to lift the plotter's pen off 
  26. the paper is PU.  To place the pen down is PD.  To draw an arc using absolute coordinates, the AA 
  27. command is used.  HP-GL/2 commands always use uppercase.  Many of these two letter commands are 
  28. followed by one or more numerical parameters.  The PU command not only lifts the pen off the paper, 
  29. but can also move the pen to a specified location.  To move the pen to the coordinates X=1016, Y=2032, 
  30. the programmer writes PU1016,2032.  The PU command is very similar to the Amiga graphics function 
  31. Move().  If the programmer wants to put the pen down and then move to X=2032, Y=5280, the PD 
  32. command appears as follows: PD2032,5280.  The PD command is similar to the Amiga's Draw() 
  33. function.  In an ASCII file the two HP-GL/2 commands generally appear one right after the other: 
  34. PU1016,2032PD2032,5280.  Each command can be terminated by a semicolon ";", but this is not 
  35. recommended for most commands because it is not required and it increases the number of bytes that 
  36. must be sent from the computer to the plotter.  This means slower plotting times for complex drawings.
  37.  
  38. The coordinates X=1016 and Y=2032 were used for a reason in the last paragraph.  The default plotter 
  39. scale is one inch equals 1016 plotter units.  Therefore, the PU1016,2032 command moves the pen to 
  40. X=1 inch and Y=2 inch.  If using the metric scale, one cm therefore equals 400 plotter units.  It is 
  41. important to note that HP-GL/2's default page orientation is Landscape.  Therefore, the X axis is oriented 
  42. along the long axis of the paper (the 11 inch side on an 8.5x11 inch paper).  This is different from 
  43. PostScript's default page orientation which is Portrait.  As for PostScript, the default origin in the 
  44. HP-GL/2 coordinate system is the lower left corner of the paper.  HP-GL/2 allows the user to define 
  45. their own scale when drawing, but the resolution of the device cannot be any finer than 1/1016th of an 
  46. inch (0.00098 inch).  This should prove more than adequate for most applications.
  47.  
  48. HP-GL/2's default plotter units may be a bit cumbersome to work with.  Therefore, the user can define 
  49. their own scaling system.  By using the SC command, the user can define plotter coordinates in inches.  
  50. Once the SC command is used to scale plotter units to inches, all page coordinates are interpreted as 
  51. inches.  The above PU1016,2032 command would be written as PU1.0,2.0.  Another common way to 
  52. scale the coordinate system is to set the page up to equal the screen coordinates.  For example, if the 
  53. screen size is 640x400 pixels, the plotter page can be scaled to 640 units along the 11 inch X axis and 
  54. 400 units along the 8.5 inch Y axis.  Therefore, when sending a screen oriented drawing to the plotter, no 
  55. further manipulations are needed.  Because the plotter has a much higher resolution than the screen, all 
  56. coordinate calculations should be done with at least 5 digits resolution and the numbers rounded off 
  57. when they are used for drawing to the screen.  For example, coordinate 325.257, 185.961 is sent to the 
  58. plotter unchanged, while the numbers 325, 186 are used to draw to the screen.
  59.  
  60. To change the scale of the plot the user issues the SC command which has a parameter list as follows: 
  61. SC Xmin, Xmax, Ymin, Ymax.  To set the plotter scale to equal that of a 640x400 pixel Amiga screen, 
  62. the user writes the SC command as follows:
  63.  
  64. SC0.0,640.0,400.0,0.0
  65.  
  66. Note that Ymin was entered as 400.0.  This is because the left lower corner of the plotter coordinate 
  67. system is Xmin=0, Ymin=0, while the left lower corner of am Amiga screen is Xmin=0, Ymax=400.  
  68. After the SC command is executed the plotter scale mimics the screen's scale with lower Y values being 
  69. closer to the top of the page.  Instead of altering the plotters coordinates, the programmer may decide to 
  70. alter the screen coordinates as was done with the MAP_Y() definition in the first article.
  71.  
  72. Another important aspect of the plotter's coordinate system that must be learned is the use of the scaling 
  73. points P1 and P2.  One is tempted to assume that the SC, scale, command is used to enlarge or reduce a 
  74. plot's size.  This is not the case.  SC sets the units of measure that the plotter uses to specify location.  
  75. The scaling points P1 and P2 control any enlarging or reducing of a plot.  Usually, the plotter will be 
  76. initialized with the IN command before any plot-specific commands are sent.  IN sets P1 and P2 to the 
  77. default values.  P1 is at the lower left corner and P2 is at the upper right corner.  An SC command must 
  78. then be issued to set up a scale that the P1 and P2 points will use.  To reduce the subsequent plot, points 
  79. P1 and P2 are moved closer together.  To enlarge the plot, P1 and P2 are moved further apart.  The IP, or 
  80. input P1 and P2, command is used to change the locations of P1 and P2.  The parameter list for IP is:
  81.  
  82. IP P1x, P1y, P2x, P2y 
  83.  
  84. Of note, instead of using the IN command to set P1 and P2 to the default parameters, the user can set the 
  85. initial P1 and P2 locations using the IP command.
  86.  
  87. To reduce a plot in half, the following pseudocode can be used.
  88.  
  89. IP0,0,2000,2000
  90. SC0,640.0,400.0,0.0
  91. IP500,500,1500,1500
  92. /* now draw the plot */
  93.  
  94. P1 is first set to location 0,0 (i.e. lower left corner) and P2 to 2000,2000.  Next, the plot is scaled using 
  95. the SC command.  Reducing and enlarging can only occur when the scaling points (P1, P2) are used in 
  96. concert with the scaling command (SC).  The next occurrence of the IP command moves P1 and P2 
  97. closer by 1000 plotter units.  This effectively reduces the final plot size in half.  The plot was to be 2000 
  98. unit by 2000 units.  It is now 1000 units by 1000.  This is a very simplified view of the use of the IP and 
  99. SC commands, but it provides a flavor for the potential.  Of note, remember that HP-GL/2 commands 
  100. are not entered with only one command per line as in the previous examples.  The actual appearance of 
  101. the commands in a file would be:
  102.  
  103. IP0,0,2000,2000,SC0,400,640,0,IP500,500,1500,1500;
  104.  
  105. It is time to create our first drawing.  To keep it simple, we will just create a small rectangle.  The 
  106. HP-GL/2 code is generated using a simple C language file.  Almost any language will do.  The HP-GL/2 
  107. code can even be entered directly into a text editor.
  108.  
  109. #include <stdio.h>
  110.  
  111. void main(main){
  112.      printf("%c%%-1BBPINSP1SC0.0,640.0,400.0,0.0", 27);
  113.      printf("PU100,100PD200,100PD200,200PD100,200PD100,100");
  114.      printf("PUSP0PG;");
  115.      exit(0);
  116.  }
  117.  
  118. Save the program as HPrec.c, compile and link.  From the CLI, send the output of the command to 
  119. whichever device, either the serial or parallel port, the plotter is attached to.
  120.  
  121.      HPrec > par:
  122.  
  123. A rectangle should be drawn by the plotter.
  124.  
  125. The first printf() statement contains many new commands that must be mentioned.  Fortunately, most of 
  126. this first line can remain unchanged for the majority of plots.  The first part of the string %c%%-1B" 
  127. (human readable==ESC%-1B) ensures that the device is in HP-GL/2 mode.  Many newer laser printers 
  128. support HP-GL/2 in addition to the more traditional PCL and PostScript capabilities.  This command 
  129. tells the device to select HP-GL/2 emulation mode.  The BP command stands for Begin Plot.  This 
  130. informs the plotter device to prepare a new piece of paper.  It also informs any plotter that supports both 
  131. HP-GL and HP-GL/2 to select HP-GL/2 emulation mode.  The IN, Initialize Plotter, command does just 
  132. that.  It initializes the plotter back to its default settings.  The SP1 command Selects Pen number 1.  On a 
  133. multi-pen machine, this foreground color is usually black.  The SC command has already been 
  134. discussed.  Any graphics commands that follow will now use coordinates similar to screen coordinates.
  135.  
  136. The next printf() command creates the rectangle.  PU100,100 lifts the pen off the paper and moves to 
  137. position 100,100.  The following PD commands put the pen down on the paper and draw the four sides 
  138. of the rectangle.  Of note, the preferred method of writing the PD command is somewhat different than 
  139. shown.  To decrease the number of bytes that must be sent to the plotter, the PD command can be used 
  140. once and all the following PD-related coordinates follow.  For example, the command can be written as:
  141.  
  142. printf("PU100,100PD200,100,200,200,100,200,100,100");
  143.  
  144. A number of HP-GL/2 commands work this way.  You do not have to re-write the PD command until 
  145. you use another command.  Therefore, you can draw a multi-sided polygon using one PD command 
  146. followed only by the actual numerical coordinates.
  147.  
  148. The final printf() command terminates the plot.  PU lifts the pen off the paper.  SP0 selects pen 0.  This 
  149. command basically puts pen 1 away so the ink will not dry out.  The PG command tells the plotter that 
  150. the plot is done and to advance the page if the device supports this feature.  If the device cannot advance 
  151. the page, the plotter is set to a Not Ready state so that the user has to manually advance the page.  Please 
  152. note that PG must be followed by a semicolon.  The one exception to this rule is that the PG command 
  153. can be followed by the RP command which must be terminated with a semicolon.  RP stands for RePlot 
  154. and can be used to instruct the plotter to make multiple copies of the current drawing.  The number of 
  155. copies RP creates is controlled by an integer value that follows the RP command.  To create 10 copies of 
  156. the current plot the command is: "PGRP10;".  Please note than not all devices support the RePlot 
  157. command.
  158.  
  159. A hardcoded printf()-based rectangle program is limited in usefulness.  Therefore, let us write a simple 
  160. function that can draw an outline rectangle either to the screen or to an HP-GL/2 device.
  161.  
  162.  void sd_rect(float xmin, float ymin, float xmax, float ymax, int color, int l_thick){
  163.      if(Output_Device==SCREEN){    /* send to screen */
  164.          SetAPen(rp, color);
  165.          Move(sd_rp, xmin,ymin);
  166.          Draw(sd_rp, xmax,ymin);
  167.          Draw(sd_rp, xmax,ymax);
  168.          Draw(sd_rp, xmin,ymax);
  169.          Draw(sd_rp, xmin,ymin);
  170.      }
  171.      else{
  172.          fprintf(Outfp,"SP%dPW%.3f", color,(float)(l_thick) *0.35);
  173.          fprintf(Outfp,"PU%f,%fPD%f,%f,%f,%f,%f,%f,%f,%f",
  174.              xmin,ymin,xmax,ymin,xmax,ymax,xmin,ymax,xmin,ymin);
  175.      }
  176.      return;
  177.  }
  178.  
  179. Many programming methods are possible for a function similar to sd_rect(), but this code was kept 
  180. simple for ease of understanding.  The first fprinf() statement sets the pen color using the SP command.  
  181. Although HP-GL/2 can compensate for an attempt at selecting a pen number (i.e. color) greater than 
  182. supported by the plotter, it is best if the programmer keeps track of this.  The PW command sets the Pen 
  183. Width.  The default pen width is 0.35 mm.  Therefore in our example we convert the screen oriented 
  184. l_thick variable to the Pen Width acceptable measure by multiplying 0.35 times l_thick.  On many 
  185. HP-GL/2 devices, selecting a Pen Width greater than 0.35 mm results in the plotter making two or more 
  186. passes with the pen.  If the pen in the plotter is 0.35 mm thick, it is not possible to reduce line thickness 
  187. below this.
  188.  
  189. The next fprintf() call is self explanatory and creates the outline of the rectangle.  It is suggested to limit 
  190. the number of decimals sent to the plotter by modifying the fprintf() command.  Use something line 
  191. PU%.3f,%.3fPD%.3f,%.3f..... to limit the decimal places.
  192.  
  193. Many times a rectangle must be filled with a specific color or pattern.  HP-GL/2 supports a number of 
  194. approaches to this problem.  The simplest program relies on the RA (fill Rectangle Absolute) command.  
  195. The command syntax is:
  196.     RAx,y
  197. The first step to using the RA command is to use another command to position the pen at the upper left 
  198. corner of the desired rectangle.  Therefore, a command string such as PU100,100RA200,200 creates a 
  199. square with the upper left corner at coordinates 100,100 and the lower right corner at 200, 200.  The 
  200. defined rectangle is filled in with the currently defined pen color and fill type.
  201.  
  202. Fill Type is set by use of the FT command.  The fills that FT can create are: solid, parallel lines, 
  203. crosshatched, or patterned (raster) fills.  FT allows the programmer to define fill patterns for polygons, 
  204. rectangles, characters, and wedges (pie slices).  The syntax for fill type is:
  205.  
  206.     FT fill type(,option1, option2)
  207.  
  208. Setting fill type to 1 or 2 produces a solid color fill.  The color of the fill is determined by the currently 
  209. selected pen (SP command).  Options 1 and 2 are ignored for fill types 1 and 2.  Setting fill type to 3 
  210. produces a fill composed of parallel lines.  Option 1 determines the spacing between each line while 
  211. Option 2 determines the angle of the lines, where 0 degrees produces a horizontal line.  Setting fill type 
  212. to 4 produces a crosshatched line.  Options 1 and 2 are as discussed above.  Setting fill type to 10 
  213. produces a shading effect.  The percent of shading is determined by setting Option1 to the desired shade.  
  214. The percent of shading varies from 1-100%.  One percent shading is almost no shading while 100% 
  215. shading is a solid color.
  216.  
  217. HP-GL/2 provides control over the pattern used to draw lines.  The format of the Line Type (LT) 
  218. command is:
  219.  
  220.     LTline type(,pattern length(,mode;))
  221.  
  222. To create a solid line, the LT command without parameters is sent to the plotter.  Setting the line type 
  223. parameter to a number between 1 and 8 selects a pre-defined line pattern.  HP-GL/2 supports eight 
  224. pre-defined line types.  The pattern length parameter determines the distance it takes to complete one 
  225. pattern unit.  If the mode parameter is set to "0", the value entered for the pattern length is a percentage 
  226. of the diagonal distance between P1 and P2.  The default is 4%.  If the mode parameter is set to "1", the 
  227. pattern length variable is interpreted in millimeters.
  228.  
  229. We now know how to move the pen, draw lines, change the colors of lines, set the line pattern, and the 
  230. line thickness.  Creating functions that mimic the Amiga's Move() and Draw() functions is 
  231. straightforward.
  232.  
  233.  /* global variables same as for Part 1 */
  234.  #define  HPGL    2
  235.  
  236.  void sd_Move(float x1, float y1){
  237.      if(Output_Device==SCREEN){
  238.          Move(sd_rp, (ULONG)(x1+0.5), (ULONG)(y1+0.5));
  239.      }
  240.      else if(Output_Device==HPGL){
  241.          fprintf(Outfp,"PU%.3f,%.3f", x1, y1);
  242.      }
  243.      return;
  244.  }
  245.  
  246.  void sd_Draw(float x1, float y1, int color, int pat, int l_thick){
  247.      int i=0;
  248.  
  249.      if(Output_Device==SCREEN){
  250.          /*  See Part 1  */
  251.      }
  252.      else if(Output_Device==HPGL){
  253.          fprintf(Outfp,"SP%dPW%.3fLT%d,2,0PD%.3f,%.3f",color,
  254.              0.35*l_thick,pat,x1, y1);
  255.      }
  256.      return;
  257.  }
  258.  
  259. Although these two functions allow us to draw almost any wireframe shape, many drawings require 
  260. patterned fills of irregular shapes or complex filled patterns.  HP-GL/2 supports a Polygon Mode (PM) 
  261. command.  This command instructs the plotter to store all subsequent vector commands such as PU and 
  262. PD so that we can then fill the complex shape with any color or pattern we choose.
  263.  
  264. Sending the PM0 command to the plotter instructs the plotter to enter the polygon mode.  Of note, the 
  265. initial vertex of our polygon will be the current pen position when we call PM0.  Therefore, a PU or PA 
  266. command should move the pen to the first vertex of the polygon.  After the PM0 command is entered, 
  267. the user sends a series of HP-GL/2 commands to define the polygon (e.g. PD, AA, CI, etc.).  It is 
  268. recommended to close the polygon by ensuring that the last X, Y coordinate given when defining the 
  269. polygon is the same as the X, Y coordinate used to define the first vertex.
  270.  
  271. Once the polygon is defined, the user sends the PM2 command to the plotter.  This terminates the 
  272. polygon and returns the plotter to a non-polygon mode.  To fill a polygon, send the FP (Fill Polygon) 
  273. command to the plotter.  To edge the polygon, send the EP (Edge Polygon) command to the plotter.  It is 
  274. permissible to send both commands to the plotter such as FPEP so that the polygon is edged and filled.  
  275. The pen color of the fill or edge is set by the currently-defined color as set by the SP command.  The fill 
  276. pattern used is set by calling the FT command prior to sending the FP command.  In the same manner, 
  277. the line type used for the edging is determined by the currently defined line type which is set using the 
  278. LT command.
  279.  
  280. By programming a polygon function, we can create almost any shape we desire by just using this one 
  281. function.  Therefore, we could use this function instead of the one we created above that drew a 
  282. rectangle.  This polygon function can be used to create circles or ellipses.  It is possible to create 
  283. complex polygons within polygons by use of the PM1 command, but I will just suggest the possibility 
  284. and refer the interested reader to the references stated at the end of this article.  One point to keep in 
  285. mind is that not all devices that support HP-GL have a polygon buffer.  For example, the HP7475A 
  286. plotter cannot take advantage of the PM commands.
  287.  
  288. Creating a polygon function requires that we pass X and Y arrays of vertices values.  We must also 
  289. inform the function of the number of points, as well as the fill type, line type, color, and whether to fill, 
  290. edge, or both.  A simple function is presented.
  291.  
  292. void sd_polygon(float *x, float *y, int pts, int f_color, int
  293.      l_color, int f_pat, int l_pat, int l_thick, BOOL fill, BOOL edge){
  294.      int i=0;
  295.  
  296.      if(Output_Device==SCREEN){
  297.         /* see part 1 sd_AreaDraw2() */
  298.      }
  299.      else if(Output_Device==HPGL){
  300.          fprintf(Outfp,"PU%.3f,%.3fFT%dLT%dPM0PD", x[0], y[0], f_pat,l_pat);
  301.          for(i=1;i<(pts-1);i++)    fprintf("%.3f,%.3f,",x[i],y[i]);
  302.          fprintf("%.3f,%.3fPM2", x[pts-1], y[pts-1]);
  303.          if(fill)    fprintf("SP%dFP", f_color);
  304.          if(edge)    fprintf("SP%dEP",l_color);
  305.      }
  306.      return;
  307.  }
  308.  
  309. The HP-GL/2 command set does not have anywhere near the level of control over text that PostScript 
  310. does, but HP-GL/2 does support simple plotting of text.  Some of the newer plotters and many of the 
  311. raster-type devices (laser printers) that support HP-GL/2 commands even allow the user to select various 
  312. font families.  The basic plotter usually has a default "stick" font built in that is used to plot text.  Such a 
  313. basic plotter will not allow the selection of alternate font families, but will allow significant control over 
  314. the size, width, and slant of the font.  Even for plotters that only support a stick font, the resourceful 
  315. programmer can send HP-GL/2 commands to the plotter to create any desired font type by defining the 
  316. font's shape.
  317.  
  318. The most important command for drawing text is the LB, or LaBel, command.  This command is 
  319. followed by the desired text string and a specific string terminator that signifies the end of the text string.  
  320. When the LB command is sent to the plotter, the left edge of the text is placed at the current pen position 
  321. using the currently defined font, font size, and color.  The default string terminator is the non-printing 
  322. end-of-text character ETX (decimal 3 in the ASCII character set).  If this string terminator is not placed 
  323. at the end of the text, all HP-GL/2 commands following the first LB command are printed as part of the 
  324. text string.
  325.  
  326.  An example LB command using a C function is:
  327.      fprintf(Outfp,"LB%s%c", "Example Text", 3);
  328.  
  329. It is a rather simple matter to create a function that mimics the AmigaDOS Text() function for output to 
  330. an HP-GL/2 device.
  331.  
  332.  void sd_Text(char *str, int color){
  333.      if(Output_Device==SCREEN){
  334.          SetAPen(sd_rp, color);
  335.          Text(sd_rp, str, strlen(str));
  336.      }
  337.      else if(Output_Device==HPGL){
  338.          fprintf(Outfp,"SP%dLB%s%c", color, str, 3);
  339.      }
  340.      return;
  341.  }
  342.  
  343. Many plotters only support stick fonts.  If your HP-GL/2 device supports a range of fonts, you may want 
  344. to use the SD, Standard Font Definition, command.  This determines which character set, typeface, and 
  345. other parameters to use for the default font.  The parameter list for this command is:
  346.  
  347.     SDkind,value(,kind,value,kind,value,etc.)
  348.  where kind can be the integer values:
  349.      1    Character set, default value = 0 = Roman8
  350.      2    Font spacing, default value = 0 = fixed
  351.      3    Pitch, default value is media dependent
  352.      4    Height, default value is media dependent
  353.      5    Posture, default value is device dependent(normal,italic)
  354.      6    Stroke weight, default value = 0 = normal
  355.      7    Typeface, default value = 48 = stick fonts
  356.  
  357. A typical SD command might be:
  358.      SD2,1,4,14,5,0,6,3,7,5;
  359.  
  360. The 2,1 pair sets font spacing (2) to proportional (1).  The 4,14 pair sets font height (4), to 14 points 
  361. (14).  The 5,0 pair sets posture (5) to upright (0), the 6,3 pair sets stroke weight (6) to bold (3), and the 
  362. 7,5 pair sets the typeface (7) to Times Roman (5).
  363.  
  364. Another text/font related command I find useful is the SI, Absolute Character Size, command.  It sets the 
  365. height and width of a font to a specific size in centimeters.  Because the plotter I use does not support 
  366. typefaces besides stick fonts, the SD command is of limited usefulness.  The SI command on the other 
  367. hand allows me to size text so that the HP-GL/2 outputted text is the same relative size as what appears 
  368. on screen.  I have found that bullet fonts as supported by AmigaDOS are generally about 20% narrower 
  369. than either PostScript or HP-GL/2 fonts.  The SI command allows me to compensate for that discrepancy 
  370. as well as determine the character height.  Because the SI command is an absolute measure in 
  371. centimeters, it is up to the programmer to scale the character size if the plot is scaled by altering the P1 
  372. and P2 positions.
  373.  
  374. The SI command parameter list is:
  375.     SIwidth,height;
  376.  
  377. A typical SI command in C might be:
  378.     fprintf(Outfp,"SI%.3f,%.3f",width, height);
  379.  
  380. A simple C function to scale the currently selected font for an HP-GL/2 graph is as follows.
  381.  
  382.  void sd_FontSz(float fsize){    /* fsize is font size in points */
  383.      if(Output_Device==HPGL){
  384.          fprintf(Outfp,"SI%.3f,%.3f",fsize*0.5*2.54/72.*xscale,fsize*2.54/72.*yscale);
  385.      }
  386.      return;
  387.  }
  388.  
  389. The 2.54/72. calculation changes the font size in points to font size in centimeters.  The xscale and 
  390. yscale variables will decrease or increase the font size the appropriate amount if the entire plot is scaled.  
  391. The 0.5 correction factor is arbitrary to have the font width of the HP-GL/2 text similar to the 
  392. AmigaDOS on-screen font width.
  393.  
  394. Although the HP-GL/2 command set is much larger than presented here, any hobbyist programmer can 
  395. create some impressive plotter graphics using the commands presented.  As stated in the previous article, 
  396. I have included a simple C program entitled StructDraw.c that further demonstrates the HP-GL/2 
  397. language.  The interested programmer can use this code as a basis for a more impressive program.
  398.  
  399. References:
  400. HP-GL/2
  401. The HP-GL/2 Reference Guide: A Handbook for Program Developers, Hewlett-Packard, 
  402. Addison-Wesley Publishing, 1990.
  403.  
  404. HP-GL
  405. Interfacing and Programming Manual: HP 7475A Graphics Plotter, Hewlett Packard
  406.  
  407.